// $ANTLR 3.4 Python.g 2012-12-31 09:59:56

import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;

@SuppressWarnings({"all", "warnings", "unchecked"})
public class PythonLexer extends Lexer {
    public static final int EOF=-1;
    public static final int T__84=84;
    public static final int T__85=85;
    public static final int T__86=86;
    public static final int T__87=87;
    public static final int T__88=88;
    public static final int T__89=89;
    public static final int T__90=90;
    public static final int T__91=91;
    public static final int T__92=92;
    public static final int T__93=93;
    public static final int T__94=94;
    public static final int T__95=95;
    public static final int T__96=96;
    public static final int T__97=97;
    public static final int T__98=98;
    public static final int T__99=99;
    public static final int T__100=100;
    public static final int T__101=101;
    public static final int T__102=102;
    public static final int T__103=103;
    public static final int T__104=104;
    public static final int T__105=105;
    public static final int T__106=106;
    public static final int T__107=107;
    public static final int T__108=108;
    public static final int T__109=109;
    public static final int T__110=110;
    public static final int T__111=111;
    public static final int T__112=112;
    public static final int ALT_NOTEQUAL=4;
    public static final int AMPER=5;
    public static final int AMPEREQUAL=6;
    public static final int ASSIGN=7;
    public static final int BACKQUOTE=8;
    public static final int BLOCK=9;
    public static final int BRACKETED=10;
    public static final int CIRCUMFLEX=11;
    public static final int CIRCUMFLEXEQUAL=12;
    public static final int CLASS_DEF=13;
    public static final int COLON=14;
    public static final int COMMA=15;
    public static final int COMMENT=16;
    public static final int COMPLEX=17;
    public static final int COMPOUND_STATMENT=18;
    public static final int CONTINUED_LINE=19;
    public static final int DEDENT=20;
    public static final int DIGITS=21;
    public static final int DOT=22;
    public static final int DOUBLESLASH=23;
    public static final int DOUBLESLASHEQUAL=24;
    public static final int DOUBLESTAR=25;
    public static final int DOUBLESTAREQUAL=26;
    public static final int EQUAL=27;
    public static final int ESC=28;
    public static final int EXCEPT_STATMENT=29;
    public static final int EXPRESSION_STATMENT=30;
    public static final int Exponent=31;
    public static final int FINALLY_STATMENT=32;
    public static final int FLOAT=33;
    public static final int FOR_STATMENT=34;
    public static final int FUNCTION_DEF=35;
    public static final int GREATER=36;
    public static final int GREATEREQUAL=37;
    public static final int IF_STATMENT=38;
    public static final int IMPORT_STATMENT=39;
    public static final int INDENT=40;
    public static final int INT=41;
    public static final int LBRACK=42;
    public static final int LCURLY=43;
    public static final int LEADING_WS=44;
    public static final int LEFTSHIFT=45;
    public static final int LEFTSHIFTEQUAL=46;
    public static final int LESS=47;
    public static final int LESSEQUAL=48;
    public static final int LONGINT=49;
    public static final int LPAREN=50;
    public static final int MINUS=51;
    public static final int MINUSEQUAL=52;
    public static final int NAME=53;
    public static final int NEWLINE=54;
    public static final int NOTEQUAL=55;
    public static final int PARAMETERS=56;
    public static final int PERCENT=57;
    public static final int PERCENTEQUAL=58;
    public static final int PLUS=59;
    public static final int PLUSEQUAL=60;
    public static final int RBRACK=61;
    public static final int RCURLY=62;
    public static final int RETURN_STATMENT=63;
    public static final int RIGHTSHIFT=64;
    public static final int RIGHTSHIFTEQUAL=65;
    public static final int RPAREN=66;
    public static final int SEMI=67;
    public static final int SIMPLE_STATMENT=68;
    public static final int SLASH=69;
    public static final int SLASHEQUAL=70;
    public static final int STAR=71;
    public static final int STAREQUAL=72;
    public static final int STATMENT=73;
    public static final int STRING=74;
    public static final int TESTLIST=75;
    public static final int TILDE=76;
    public static final int TRY_STATMENT=77;
    public static final int TUPLE=78;
    public static final int VARIABLE=79;
    public static final int VBAR=80;
    public static final int VBAREQUAL=81;
    public static final int WHILE_STATMENT=82;
    public static final int WS=83;

    /** Handles context-sensitive lexing of implicit line joining such as
     *  the case where newline is ignored in cases like this:
     *  a = [3,
     *       4]
     */
    int implicitLineJoiningLevel = 0;
    int startPos=-1;


    // delegates
    // delegators
    public Lexer[] getDelegates() {
        return new Lexer[] {};
    }

    public PythonLexer() {} 
    public PythonLexer(CharStream input) {
        this(input, new RecognizerSharedState());
    }
    public PythonLexer(CharStream input, RecognizerSharedState state) {
        super(input,state);
    }
    public String getGrammarFileName() { return "Python.g"; }

    // $ANTLR start "T__84"
    public final void mT__84() throws RecognitionException {
        try {
            int _type = T__84;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:17:7: ( 'and' )
            // Python.g:17:9: 'and'
            {
            match("and"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__84"

    // $ANTLR start "T__85"
    public final void mT__85() throws RecognitionException {
        try {
            int _type = T__85;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:18:7: ( 'assert' )
            // Python.g:18:9: 'assert'
            {
            match("assert"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__85"

    // $ANTLR start "T__86"
    public final void mT__86() throws RecognitionException {
        try {
            int _type = T__86;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:19:7: ( 'break' )
            // Python.g:19:9: 'break'
            {
            match("break"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__86"

    // $ANTLR start "T__87"
    public final void mT__87() throws RecognitionException {
        try {
            int _type = T__87;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:20:7: ( 'class' )
            // Python.g:20:9: 'class'
            {
            match("class"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__87"

    // $ANTLR start "T__88"
    public final void mT__88() throws RecognitionException {
        try {
            int _type = T__88;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:21:7: ( 'continue' )
            // Python.g:21:9: 'continue'
            {
            match("continue"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__88"

    // $ANTLR start "T__89"
    public final void mT__89() throws RecognitionException {
        try {
            int _type = T__89;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:22:7: ( 'def' )
            // Python.g:22:9: 'def'
            {
            match("def"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__89"

    // $ANTLR start "T__90"
    public final void mT__90() throws RecognitionException {
        try {
            int _type = T__90;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:23:7: ( 'del' )
            // Python.g:23:9: 'del'
            {
            match("del"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__90"

    // $ANTLR start "T__91"
    public final void mT__91() throws RecognitionException {
        try {
            int _type = T__91;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:24:7: ( 'elif' )
            // Python.g:24:9: 'elif'
            {
            match("elif"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__91"

    // $ANTLR start "T__92"
    public final void mT__92() throws RecognitionException {
        try {
            int _type = T__92;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:25:7: ( 'else' )
            // Python.g:25:9: 'else'
            {
            match("else"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__92"

    // $ANTLR start "T__93"
    public final void mT__93() throws RecognitionException {
        try {
            int _type = T__93;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:26:7: ( 'except' )
            // Python.g:26:9: 'except'
            {
            match("except"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__93"

    // $ANTLR start "T__94"
    public final void mT__94() throws RecognitionException {
        try {
            int _type = T__94;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:27:7: ( 'exec' )
            // Python.g:27:9: 'exec'
            {
            match("exec"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__94"

    // $ANTLR start "T__95"
    public final void mT__95() throws RecognitionException {
        try {
            int _type = T__95;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:28:7: ( 'finally' )
            // Python.g:28:9: 'finally'
            {
            match("finally"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__95"

    // $ANTLR start "T__96"
    public final void mT__96() throws RecognitionException {
        try {
            int _type = T__96;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:29:7: ( 'for' )
            // Python.g:29:9: 'for'
            {
            match("for"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__96"

    // $ANTLR start "T__97"
    public final void mT__97() throws RecognitionException {
        try {
            int _type = T__97;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:30:7: ( 'from' )
            // Python.g:30:9: 'from'
            {
            match("from"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__97"

    // $ANTLR start "T__98"
    public final void mT__98() throws RecognitionException {
        try {
            int _type = T__98;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:31:7: ( 'global' )
            // Python.g:31:9: 'global'
            {
            match("global"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__98"

    // $ANTLR start "T__99"
    public final void mT__99() throws RecognitionException {
        try {
            int _type = T__99;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:32:7: ( 'if' )
            // Python.g:32:9: 'if'
            {
            match("if"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__99"

    // $ANTLR start "T__100"
    public final void mT__100() throws RecognitionException {
        try {
            int _type = T__100;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:33:8: ( 'import' )
            // Python.g:33:10: 'import'
            {
            match("import"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__100"

    // $ANTLR start "T__101"
    public final void mT__101() throws RecognitionException {
        try {
            int _type = T__101;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:34:8: ( 'in' )
            // Python.g:34:10: 'in'
            {
            match("in"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__101"

    // $ANTLR start "T__102"
    public final void mT__102() throws RecognitionException {
        try {
            int _type = T__102;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:35:8: ( 'is' )
            // Python.g:35:10: 'is'
            {
            match("is"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__102"

    // $ANTLR start "T__103"
    public final void mT__103() throws RecognitionException {
        try {
            int _type = T__103;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:36:8: ( 'lambda' )
            // Python.g:36:10: 'lambda'
            {
            match("lambda"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__103"

    // $ANTLR start "T__104"
    public final void mT__104() throws RecognitionException {
        try {
            int _type = T__104;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:37:8: ( 'not' )
            // Python.g:37:10: 'not'
            {
            match("not"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__104"

    // $ANTLR start "T__105"
    public final void mT__105() throws RecognitionException {
        try {
            int _type = T__105;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:38:8: ( 'or' )
            // Python.g:38:10: 'or'
            {
            match("or"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__105"

    // $ANTLR start "T__106"
    public final void mT__106() throws RecognitionException {
        try {
            int _type = T__106;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:39:8: ( 'pass' )
            // Python.g:39:10: 'pass'
            {
            match("pass"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__106"

    // $ANTLR start "T__107"
    public final void mT__107() throws RecognitionException {
        try {
            int _type = T__107;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:40:8: ( 'print' )
            // Python.g:40:10: 'print'
            {
            match("print"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__107"

    // $ANTLR start "T__108"
    public final void mT__108() throws RecognitionException {
        try {
            int _type = T__108;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:41:8: ( 'raise' )
            // Python.g:41:10: 'raise'
            {
            match("raise"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__108"

    // $ANTLR start "T__109"
    public final void mT__109() throws RecognitionException {
        try {
            int _type = T__109;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:42:8: ( 'return' )
            // Python.g:42:10: 'return'
            {
            match("return"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__109"

    // $ANTLR start "T__110"
    public final void mT__110() throws RecognitionException {
        try {
            int _type = T__110;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:43:8: ( 'try' )
            // Python.g:43:10: 'try'
            {
            match("try"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__110"

    // $ANTLR start "T__111"
    public final void mT__111() throws RecognitionException {
        try {
            int _type = T__111;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:44:8: ( 'while' )
            // Python.g:44:10: 'while'
            {
            match("while"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__111"

    // $ANTLR start "T__112"
    public final void mT__112() throws RecognitionException {
        try {
            int _type = T__112;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:45:8: ( 'yield' )
            // Python.g:45:10: 'yield'
            {
            match("yield"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "T__112"

    // $ANTLR start "LPAREN"
    public final void mLPAREN() throws RecognitionException {
        try {
            int _type = LPAREN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:417:8: ( '(' )
            // Python.g:417:10: '('
            {
            match('('); 

            implicitLineJoiningLevel++;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "LPAREN"

    // $ANTLR start "RPAREN"
    public final void mRPAREN() throws RecognitionException {
        try {
            int _type = RPAREN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:419:8: ( ')' )
            // Python.g:419:10: ')'
            {
            match(')'); 

            implicitLineJoiningLevel--;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "RPAREN"

    // $ANTLR start "LBRACK"
    public final void mLBRACK() throws RecognitionException {
        try {
            int _type = LBRACK;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:421:8: ( '[' )
            // Python.g:421:10: '['
            {
            match('['); 

            implicitLineJoiningLevel++;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "LBRACK"

    // $ANTLR start "RBRACK"
    public final void mRBRACK() throws RecognitionException {
        try {
            int _type = RBRACK;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:423:8: ( ']' )
            // Python.g:423:10: ']'
            {
            match(']'); 

            implicitLineJoiningLevel--;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "RBRACK"

    // $ANTLR start "COLON"
    public final void mCOLON() throws RecognitionException {
        try {
            int _type = COLON;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:425:8: ( ':' )
            // Python.g:425:10: ':'
            {
            match(':'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "COLON"

    // $ANTLR start "COMMA"
    public final void mCOMMA() throws RecognitionException {
        try {
            int _type = COMMA;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:427:7: ( ',' )
            // Python.g:427:9: ','
            {
            match(','); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "COMMA"

    // $ANTLR start "SEMI"
    public final void mSEMI() throws RecognitionException {
        try {
            int _type = SEMI;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:429:6: ( ';' )
            // Python.g:429:8: ';'
            {
            match(';'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "SEMI"

    // $ANTLR start "PLUS"
    public final void mPLUS() throws RecognitionException {
        try {
            int _type = PLUS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:431:6: ( '+' )
            // Python.g:431:8: '+'
            {
            match('+'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "PLUS"

    // $ANTLR start "MINUS"
    public final void mMINUS() throws RecognitionException {
        try {
            int _type = MINUS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:433:7: ( '-' )
            // Python.g:433:9: '-'
            {
            match('-'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "MINUS"

    // $ANTLR start "STAR"
    public final void mSTAR() throws RecognitionException {
        try {
            int _type = STAR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:435:6: ( '*' )
            // Python.g:435:8: '*'
            {
            match('*'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "STAR"

    // $ANTLR start "SLASH"
    public final void mSLASH() throws RecognitionException {
        try {
            int _type = SLASH;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:437:7: ( '/' )
            // Python.g:437:9: '/'
            {
            match('/'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "SLASH"

    // $ANTLR start "VBAR"
    public final void mVBAR() throws RecognitionException {
        try {
            int _type = VBAR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:439:6: ( '|' )
            // Python.g:439:8: '|'
            {
            match('|'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "VBAR"

    // $ANTLR start "AMPER"
    public final void mAMPER() throws RecognitionException {
        try {
            int _type = AMPER;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:441:7: ( '&' )
            // Python.g:441:9: '&'
            {
            match('&'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "AMPER"

    // $ANTLR start "LESS"
    public final void mLESS() throws RecognitionException {
        try {
            int _type = LESS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:443:6: ( '<' )
            // Python.g:443:8: '<'
            {
            match('<'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "LESS"

    // $ANTLR start "GREATER"
    public final void mGREATER() throws RecognitionException {
        try {
            int _type = GREATER;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:445:9: ( '>' )
            // Python.g:445:11: '>'
            {
            match('>'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "GREATER"

    // $ANTLR start "ASSIGN"
    public final void mASSIGN() throws RecognitionException {
        try {
            int _type = ASSIGN;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:447:8: ( '=' )
            // Python.g:447:10: '='
            {
            match('='); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "ASSIGN"

    // $ANTLR start "PERCENT"
    public final void mPERCENT() throws RecognitionException {
        try {
            int _type = PERCENT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:449:9: ( '%' )
            // Python.g:449:11: '%'
            {
            match('%'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "PERCENT"

    // $ANTLR start "BACKQUOTE"
    public final void mBACKQUOTE() throws RecognitionException {
        try {
            int _type = BACKQUOTE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:451:11: ( '`' )
            // Python.g:451:13: '`'
            {
            match('`'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "BACKQUOTE"

    // $ANTLR start "LCURLY"
    public final void mLCURLY() throws RecognitionException {
        try {
            int _type = LCURLY;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:453:8: ( '{' )
            // Python.g:453:10: '{'
            {
            match('{'); 

            implicitLineJoiningLevel++;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "LCURLY"

    // $ANTLR start "RCURLY"
    public final void mRCURLY() throws RecognitionException {
        try {
            int _type = RCURLY;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:455:8: ( '}' )
            // Python.g:455:10: '}'
            {
            match('}'); 

            implicitLineJoiningLevel--;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "RCURLY"

    // $ANTLR start "CIRCUMFLEX"
    public final void mCIRCUMFLEX() throws RecognitionException {
        try {
            int _type = CIRCUMFLEX;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:457:12: ( '^' )
            // Python.g:457:14: '^'
            {
            match('^'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "CIRCUMFLEX"

    // $ANTLR start "TILDE"
    public final void mTILDE() throws RecognitionException {
        try {
            int _type = TILDE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:459:7: ( '~' )
            // Python.g:459:9: '~'
            {
            match('~'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "TILDE"

    // $ANTLR start "EQUAL"
    public final void mEQUAL() throws RecognitionException {
        try {
            int _type = EQUAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:461:7: ( '==' )
            // Python.g:461:9: '=='
            {
            match("=="); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "EQUAL"

    // $ANTLR start "NOTEQUAL"
    public final void mNOTEQUAL() throws RecognitionException {
        try {
            int _type = NOTEQUAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:463:10: ( '!=' )
            // Python.g:463:12: '!='
            {
            match("!="); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "NOTEQUAL"

    // $ANTLR start "ALT_NOTEQUAL"
    public final void mALT_NOTEQUAL() throws RecognitionException {
        try {
            int _type = ALT_NOTEQUAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:465:13: ( '<>' )
            // Python.g:465:15: '<>'
            {
            match("<>"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "ALT_NOTEQUAL"

    // $ANTLR start "LESSEQUAL"
    public final void mLESSEQUAL() throws RecognitionException {
        try {
            int _type = LESSEQUAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:467:11: ( '<=' )
            // Python.g:467:13: '<='
            {
            match("<="); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "LESSEQUAL"

    // $ANTLR start "LEFTSHIFT"
    public final void mLEFTSHIFT() throws RecognitionException {
        try {
            int _type = LEFTSHIFT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:469:11: ( '<<' )
            // Python.g:469:13: '<<'
            {
            match("<<"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "LEFTSHIFT"

    // $ANTLR start "GREATEREQUAL"
    public final void mGREATEREQUAL() throws RecognitionException {
        try {
            int _type = GREATEREQUAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:471:14: ( '>=' )
            // Python.g:471:16: '>='
            {
            match(">="); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "GREATEREQUAL"

    // $ANTLR start "RIGHTSHIFT"
    public final void mRIGHTSHIFT() throws RecognitionException {
        try {
            int _type = RIGHTSHIFT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:473:12: ( '>>' )
            // Python.g:473:14: '>>'
            {
            match(">>"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "RIGHTSHIFT"

    // $ANTLR start "PLUSEQUAL"
    public final void mPLUSEQUAL() throws RecognitionException {
        try {
            int _type = PLUSEQUAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:475:11: ( '+=' )
            // Python.g:475:13: '+='
            {
            match("+="); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "PLUSEQUAL"

    // $ANTLR start "MINUSEQUAL"
    public final void mMINUSEQUAL() throws RecognitionException {
        try {
            int _type = MINUSEQUAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:477:12: ( '-=' )
            // Python.g:477:14: '-='
            {
            match("-="); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "MINUSEQUAL"

    // $ANTLR start "DOUBLESTAR"
    public final void mDOUBLESTAR() throws RecognitionException {
        try {
            int _type = DOUBLESTAR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:479:12: ( '**' )
            // Python.g:479:14: '**'
            {
            match("**"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "DOUBLESTAR"

    // $ANTLR start "STAREQUAL"
    public final void mSTAREQUAL() throws RecognitionException {
        try {
            int _type = STAREQUAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:481:11: ( '*=' )
            // Python.g:481:13: '*='
            {
            match("*="); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "STAREQUAL"

    // $ANTLR start "DOUBLESLASH"
    public final void mDOUBLESLASH() throws RecognitionException {
        try {
            int _type = DOUBLESLASH;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:483:13: ( '//' )
            // Python.g:483:15: '//'
            {
            match("//"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "DOUBLESLASH"

    // $ANTLR start "SLASHEQUAL"
    public final void mSLASHEQUAL() throws RecognitionException {
        try {
            int _type = SLASHEQUAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:485:12: ( '/=' )
            // Python.g:485:14: '/='
            {
            match("/="); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "SLASHEQUAL"

    // $ANTLR start "VBAREQUAL"
    public final void mVBAREQUAL() throws RecognitionException {
        try {
            int _type = VBAREQUAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:487:11: ( '|=' )
            // Python.g:487:13: '|='
            {
            match("|="); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "VBAREQUAL"

    // $ANTLR start "PERCENTEQUAL"
    public final void mPERCENTEQUAL() throws RecognitionException {
        try {
            int _type = PERCENTEQUAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:489:14: ( '%=' )
            // Python.g:489:16: '%='
            {
            match("%="); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "PERCENTEQUAL"

    // $ANTLR start "AMPEREQUAL"
    public final void mAMPEREQUAL() throws RecognitionException {
        try {
            int _type = AMPEREQUAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:491:12: ( '&=' )
            // Python.g:491:14: '&='
            {
            match("&="); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "AMPEREQUAL"

    // $ANTLR start "CIRCUMFLEXEQUAL"
    public final void mCIRCUMFLEXEQUAL() throws RecognitionException {
        try {
            int _type = CIRCUMFLEXEQUAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:493:17: ( '^=' )
            // Python.g:493:19: '^='
            {
            match("^="); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "CIRCUMFLEXEQUAL"

    // $ANTLR start "LEFTSHIFTEQUAL"
    public final void mLEFTSHIFTEQUAL() throws RecognitionException {
        try {
            int _type = LEFTSHIFTEQUAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:495:16: ( '<<=' )
            // Python.g:495:18: '<<='
            {
            match("<<="); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "LEFTSHIFTEQUAL"

    // $ANTLR start "RIGHTSHIFTEQUAL"
    public final void mRIGHTSHIFTEQUAL() throws RecognitionException {
        try {
            int _type = RIGHTSHIFTEQUAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:497:17: ( '>>=' )
            // Python.g:497:19: '>>='
            {
            match(">>="); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "RIGHTSHIFTEQUAL"

    // $ANTLR start "DOUBLESTAREQUAL"
    public final void mDOUBLESTAREQUAL() throws RecognitionException {
        try {
            int _type = DOUBLESTAREQUAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:499:17: ( '**=' )
            // Python.g:499:19: '**='
            {
            match("**="); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "DOUBLESTAREQUAL"

    // $ANTLR start "DOUBLESLASHEQUAL"
    public final void mDOUBLESLASHEQUAL() throws RecognitionException {
        try {
            int _type = DOUBLESLASHEQUAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:501:18: ( '//=' )
            // Python.g:501:20: '//='
            {
            match("//="); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "DOUBLESLASHEQUAL"

    // $ANTLR start "DOT"
    public final void mDOT() throws RecognitionException {
        try {
            int _type = DOT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:503:5: ( '.' )
            // Python.g:503:7: '.'
            {
            match('.'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "DOT"

    // $ANTLR start "FLOAT"
    public final void mFLOAT() throws RecognitionException {
        try {
            int _type = FLOAT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:506:2: ( '.' DIGITS ( Exponent )? | DIGITS ( '.' ( DIGITS ( Exponent )? )? | Exponent ) )
            int alt5=2;
            int LA5_0 = input.LA(1);

            if ( (LA5_0=='.') ) {
                alt5=1;
            }
            else if ( ((LA5_0 >= '0' && LA5_0 <= '9')) ) {
                alt5=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 5, 0, input);

                throw nvae;

            }
            switch (alt5) {
                case 1 :
                    // Python.g:506:4: '.' DIGITS ( Exponent )?
                    {
                    match('.'); 

                    mDIGITS(); 


                    // Python.g:506:15: ( Exponent )?
                    int alt1=2;
                    int LA1_0 = input.LA(1);

                    if ( (LA1_0=='E'||LA1_0=='e') ) {
                        alt1=1;
                    }
                    switch (alt1) {
                        case 1 :
                            // Python.g:506:16: Exponent
                            {
                            mExponent(); 


                            }
                            break;

                    }


                    }
                    break;
                case 2 :
                    // Python.g:507:9: DIGITS ( '.' ( DIGITS ( Exponent )? )? | Exponent )
                    {
                    mDIGITS(); 


                    // Python.g:507:16: ( '.' ( DIGITS ( Exponent )? )? | Exponent )
                    int alt4=2;
                    int LA4_0 = input.LA(1);

                    if ( (LA4_0=='.') ) {
                        alt4=1;
                    }
                    else if ( (LA4_0=='E'||LA4_0=='e') ) {
                        alt4=2;
                    }
                    else {
                        NoViableAltException nvae =
                            new NoViableAltException("", 4, 0, input);

                        throw nvae;

                    }
                    switch (alt4) {
                        case 1 :
                            // Python.g:507:17: '.' ( DIGITS ( Exponent )? )?
                            {
                            match('.'); 

                            // Python.g:507:21: ( DIGITS ( Exponent )? )?
                            int alt3=2;
                            int LA3_0 = input.LA(1);

                            if ( ((LA3_0 >= '0' && LA3_0 <= '9')) ) {
                                alt3=1;
                            }
                            switch (alt3) {
                                case 1 :
                                    // Python.g:507:22: DIGITS ( Exponent )?
                                    {
                                    mDIGITS(); 


                                    // Python.g:507:29: ( Exponent )?
                                    int alt2=2;
                                    int LA2_0 = input.LA(1);

                                    if ( (LA2_0=='E'||LA2_0=='e') ) {
                                        alt2=1;
                                    }
                                    switch (alt2) {
                                        case 1 :
                                            // Python.g:507:30: Exponent
                                            {
                                            mExponent(); 


                                            }
                                            break;

                                    }


                                    }
                                    break;

                            }


                            }
                            break;
                        case 2 :
                            // Python.g:507:45: Exponent
                            {
                            mExponent(); 


                            }
                            break;

                    }


                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "FLOAT"

    // $ANTLR start "LONGINT"
    public final void mLONGINT() throws RecognitionException {
        try {
            int _type = LONGINT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:511:5: ( INT ( 'l' | 'L' ) )
            // Python.g:511:9: INT ( 'l' | 'L' )
            {
            mINT(); 


            if ( input.LA(1)=='L'||input.LA(1)=='l' ) {
                input.consume();
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;
            }


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "LONGINT"

    // $ANTLR start "Exponent"
    public final void mExponent() throws RecognitionException {
        try {
            // Python.g:517:2: ( ( 'e' | 'E' ) ( '+' | '-' )? DIGITS )
            // Python.g:517:4: ( 'e' | 'E' ) ( '+' | '-' )? DIGITS
            {
            if ( input.LA(1)=='E'||input.LA(1)=='e' ) {
                input.consume();
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;
            }


            // Python.g:517:16: ( '+' | '-' )?
            int alt6=2;
            int LA6_0 = input.LA(1);

            if ( (LA6_0=='+'||LA6_0=='-') ) {
                alt6=1;
            }
            switch (alt6) {
                case 1 :
                    // Python.g:
                    {
                    if ( input.LA(1)=='+'||input.LA(1)=='-' ) {
                        input.consume();
                    }
                    else {
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        recover(mse);
                        throw mse;
                    }


                    }
                    break;

            }


            mDIGITS(); 


            }


        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "Exponent"

    // $ANTLR start "INT"
    public final void mINT() throws RecognitionException {
        try {
            int _type = INT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:519:5: ( '0' ( 'x' | 'X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+ ( 'l' | 'L' )? | '0' ( DIGITS )* | '1' .. '9' ( DIGITS )* )
            int alt11=3;
            int LA11_0 = input.LA(1);

            if ( (LA11_0=='0') ) {
                int LA11_1 = input.LA(2);

                if ( (LA11_1=='X'||LA11_1=='x') ) {
                    alt11=1;
                }
                else {
                    alt11=2;
                }
            }
            else if ( ((LA11_0 >= '1' && LA11_0 <= '9')) ) {
                alt11=3;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 11, 0, input);

                throw nvae;

            }
            switch (alt11) {
                case 1 :
                    // Python.g:520:9: '0' ( 'x' | 'X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+ ( 'l' | 'L' )?
                    {
                    match('0'); 

                    if ( input.LA(1)=='X'||input.LA(1)=='x' ) {
                        input.consume();
                    }
                    else {
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        recover(mse);
                        throw mse;
                    }


                    // Python.g:520:25: ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+
                    int cnt7=0;
                    loop7:
                    do {
                        int alt7=2;
                        int LA7_0 = input.LA(1);

                        if ( ((LA7_0 >= '0' && LA7_0 <= '9')||(LA7_0 >= 'A' && LA7_0 <= 'F')||(LA7_0 >= 'a' && LA7_0 <= 'f')) ) {
                            alt7=1;
                        }


                        switch (alt7) {
                    	case 1 :
                    	    // Python.g:
                    	    {
                    	    if ( (input.LA(1) >= '0' && input.LA(1) <= '9')||(input.LA(1) >= 'A' && input.LA(1) <= 'F')||(input.LA(1) >= 'a' && input.LA(1) <= 'f') ) {
                    	        input.consume();
                    	    }
                    	    else {
                    	        MismatchedSetException mse = new MismatchedSetException(null,input);
                    	        recover(mse);
                    	        throw mse;
                    	    }


                    	    }
                    	    break;

                    	default :
                    	    if ( cnt7 >= 1 ) break loop7;
                                EarlyExitException eee =
                                    new EarlyExitException(7, input);
                                throw eee;
                        }
                        cnt7++;
                    } while (true);


                    // Python.g:521:9: ( 'l' | 'L' )?
                    int alt8=2;
                    int LA8_0 = input.LA(1);

                    if ( (LA8_0=='L'||LA8_0=='l') ) {
                        alt8=1;
                    }
                    switch (alt8) {
                        case 1 :
                            // Python.g:
                            {
                            if ( input.LA(1)=='L'||input.LA(1)=='l' ) {
                                input.consume();
                            }
                            else {
                                MismatchedSetException mse = new MismatchedSetException(null,input);
                                recover(mse);
                                throw mse;
                            }


                            }
                            break;

                    }


                    }
                    break;
                case 2 :
                    // Python.g:523:9: '0' ( DIGITS )*
                    {
                    match('0'); 

                    // Python.g:523:13: ( DIGITS )*
                    loop9:
                    do {
                        int alt9=2;
                        int LA9_0 = input.LA(1);

                        if ( ((LA9_0 >= '0' && LA9_0 <= '9')) ) {
                            alt9=1;
                        }


                        switch (alt9) {
                    	case 1 :
                    	    // Python.g:523:13: DIGITS
                    	    {
                    	    mDIGITS(); 


                    	    }
                    	    break;

                    	default :
                    	    break loop9;
                        }
                    } while (true);


                    }
                    break;
                case 3 :
                    // Python.g:524:9: '1' .. '9' ( DIGITS )*
                    {
                    matchRange('1','9'); 

                    // Python.g:524:18: ( DIGITS )*
                    loop10:
                    do {
                        int alt10=2;
                        int LA10_0 = input.LA(1);

                        if ( ((LA10_0 >= '0' && LA10_0 <= '9')) ) {
                            alt10=1;
                        }


                        switch (alt10) {
                    	case 1 :
                    	    // Python.g:524:18: DIGITS
                    	    {
                    	    mDIGITS(); 


                    	    }
                    	    break;

                    	default :
                    	    break loop10;
                        }
                    } while (true);


                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "INT"

    // $ANTLR start "COMPLEX"
    public final void mCOMPLEX() throws RecognitionException {
        try {
            int _type = COMPLEX;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:528:5: ( INT ( 'j' | 'J' ) | FLOAT ( 'j' | 'J' ) )
            int alt12=2;
            alt12 = dfa12.predict(input);
            switch (alt12) {
                case 1 :
                    // Python.g:528:9: INT ( 'j' | 'J' )
                    {
                    mINT(); 


                    if ( input.LA(1)=='J'||input.LA(1)=='j' ) {
                        input.consume();
                    }
                    else {
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        recover(mse);
                        throw mse;
                    }


                    }
                    break;
                case 2 :
                    // Python.g:529:9: FLOAT ( 'j' | 'J' )
                    {
                    mFLOAT(); 


                    if ( input.LA(1)=='J'||input.LA(1)=='j' ) {
                        input.consume();
                    }
                    else {
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        recover(mse);
                        throw mse;
                    }


                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "COMPLEX"

    // $ANTLR start "DIGITS"
    public final void mDIGITS() throws RecognitionException {
        try {
            // Python.g:534:8: ( ( '0' .. '9' )+ )
            // Python.g:534:10: ( '0' .. '9' )+
            {
            // Python.g:534:10: ( '0' .. '9' )+
            int cnt13=0;
            loop13:
            do {
                int alt13=2;
                int LA13_0 = input.LA(1);

                if ( ((LA13_0 >= '0' && LA13_0 <= '9')) ) {
                    alt13=1;
                }


                switch (alt13) {
            	case 1 :
            	    // Python.g:
            	    {
            	    if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
            	        input.consume();
            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;
            	    }


            	    }
            	    break;

            	default :
            	    if ( cnt13 >= 1 ) break loop13;
                        EarlyExitException eee =
                            new EarlyExitException(13, input);
                        throw eee;
                }
                cnt13++;
            } while (true);


            }


        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "DIGITS"

    // $ANTLR start "NAME"
    public final void mNAME() throws RecognitionException {
        try {
            int _type = NAME;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:535:5: ( ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* )
            // Python.g:535:7: ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
            {
            if ( (input.LA(1) >= 'A' && input.LA(1) <= 'Z')||input.LA(1)=='_'||(input.LA(1) >= 'a' && input.LA(1) <= 'z') ) {
                input.consume();
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;
            }


            // Python.g:536:9: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
            loop14:
            do {
                int alt14=2;
                int LA14_0 = input.LA(1);

                if ( ((LA14_0 >= '0' && LA14_0 <= '9')||(LA14_0 >= 'A' && LA14_0 <= 'Z')||LA14_0=='_'||(LA14_0 >= 'a' && LA14_0 <= 'z')) ) {
                    alt14=1;
                }


                switch (alt14) {
            	case 1 :
            	    // Python.g:
            	    {
            	    if ( (input.LA(1) >= '0' && input.LA(1) <= '9')||(input.LA(1) >= 'A' && input.LA(1) <= 'Z')||input.LA(1)=='_'||(input.LA(1) >= 'a' && input.LA(1) <= 'z') ) {
            	        input.consume();
            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;
            	    }


            	    }
            	    break;

            	default :
            	    break loop14;
                }
            } while (true);


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "NAME"

    // $ANTLR start "STRING"
    public final void mSTRING() throws RecognitionException {
        try {
            int _type = STRING;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:546:5: ( ( 'r' | 'u' | 'ur' )? ( '\\'\\'\\'' ( options {greedy=false; } : . )* '\\'\\'\\'' | '\"\"\"' ( options {greedy=false; } : . )* '\"\"\"' | '\"' ( ESC |~ ( '\\\\' | '\\n' | '\"' ) )* '\"' | '\\'' ( ESC |~ ( '\\\\' | '\\n' | '\\'' ) )* '\\'' ) )
            // Python.g:546:9: ( 'r' | 'u' | 'ur' )? ( '\\'\\'\\'' ( options {greedy=false; } : . )* '\\'\\'\\'' | '\"\"\"' ( options {greedy=false; } : . )* '\"\"\"' | '\"' ( ESC |~ ( '\\\\' | '\\n' | '\"' ) )* '\"' | '\\'' ( ESC |~ ( '\\\\' | '\\n' | '\\'' ) )* '\\'' )
            {
            // Python.g:546:9: ( 'r' | 'u' | 'ur' )?
            int alt15=4;
            int LA15_0 = input.LA(1);

            if ( (LA15_0=='r') ) {
                alt15=1;
            }
            else if ( (LA15_0=='u') ) {
                int LA15_2 = input.LA(2);

                if ( (LA15_2=='r') ) {
                    alt15=3;
                }
                else if ( (LA15_2=='\"'||LA15_2=='\'') ) {
                    alt15=2;
                }
            }
            switch (alt15) {
                case 1 :
                    // Python.g:546:10: 'r'
                    {
                    match('r'); 

                    }
                    break;
                case 2 :
                    // Python.g:546:14: 'u'
                    {
                    match('u'); 

                    }
                    break;
                case 3 :
                    // Python.g:546:18: 'ur'
                    {
                    match("ur"); 



                    }
                    break;

            }


            // Python.g:547:9: ( '\\'\\'\\'' ( options {greedy=false; } : . )* '\\'\\'\\'' | '\"\"\"' ( options {greedy=false; } : . )* '\"\"\"' | '\"' ( ESC |~ ( '\\\\' | '\\n' | '\"' ) )* '\"' | '\\'' ( ESC |~ ( '\\\\' | '\\n' | '\\'' ) )* '\\'' )
            int alt20=4;
            int LA20_0 = input.LA(1);

            if ( (LA20_0=='\'') ) {
                int LA20_1 = input.LA(2);

                if ( (LA20_1=='\'') ) {
                    int LA20_3 = input.LA(3);

                    if ( (LA20_3=='\'') ) {
                        alt20=1;
                    }
                    else {
                        alt20=4;
                    }
                }
                else if ( ((LA20_1 >= '\u0000' && LA20_1 <= '\t')||(LA20_1 >= '\u000B' && LA20_1 <= '&')||(LA20_1 >= '(' && LA20_1 <= '\uFFFF')) ) {
                    alt20=4;
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 20, 1, input);

                    throw nvae;

                }
            }
            else if ( (LA20_0=='\"') ) {
                int LA20_2 = input.LA(2);

                if ( (LA20_2=='\"') ) {
                    int LA20_5 = input.LA(3);

                    if ( (LA20_5=='\"') ) {
                        alt20=2;
                    }
                    else {
                        alt20=3;
                    }
                }
                else if ( ((LA20_2 >= '\u0000' && LA20_2 <= '\t')||(LA20_2 >= '\u000B' && LA20_2 <= '!')||(LA20_2 >= '#' && LA20_2 <= '\uFFFF')) ) {
                    alt20=3;
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 20, 2, input);

                    throw nvae;

                }
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 20, 0, input);

                throw nvae;

            }
            switch (alt20) {
                case 1 :
                    // Python.g:547:13: '\\'\\'\\'' ( options {greedy=false; } : . )* '\\'\\'\\''
                    {
                    match("'''"); 



                    // Python.g:547:22: ( options {greedy=false; } : . )*
                    loop16:
                    do {
                        int alt16=2;
                        int LA16_0 = input.LA(1);

                        if ( (LA16_0=='\'') ) {
                            int LA16_1 = input.LA(2);

                            if ( (LA16_1=='\'') ) {
                                int LA16_3 = input.LA(3);

                                if ( (LA16_3=='\'') ) {
                                    alt16=2;
                                }
                                else if ( ((LA16_3 >= '\u0000' && LA16_3 <= '&')||(LA16_3 >= '(' && LA16_3 <= '\uFFFF')) ) {
                                    alt16=1;
                                }


                            }
                            else if ( ((LA16_1 >= '\u0000' && LA16_1 <= '&')||(LA16_1 >= '(' && LA16_1 <= '\uFFFF')) ) {
                                alt16=1;
                            }


                        }
                        else if ( ((LA16_0 >= '\u0000' && LA16_0 <= '&')||(LA16_0 >= '(' && LA16_0 <= '\uFFFF')) ) {
                            alt16=1;
                        }


                        switch (alt16) {
                    	case 1 :
                    	    // Python.g:547:47: .
                    	    {
                    	    matchAny(); 

                    	    }
                    	    break;

                    	default :
                    	    break loop16;
                        }
                    } while (true);


                    match("'''"); 



                    }
                    break;
                case 2 :
                    // Python.g:548:13: '\"\"\"' ( options {greedy=false; } : . )* '\"\"\"'
                    {
                    match("\"\"\""); 



                    // Python.g:548:19: ( options {greedy=false; } : . )*
                    loop17:
                    do {
                        int alt17=2;
                        int LA17_0 = input.LA(1);

                        if ( (LA17_0=='\"') ) {
                            int LA17_1 = input.LA(2);

                            if ( (LA17_1=='\"') ) {
                                int LA17_3 = input.LA(3);

                                if ( (LA17_3=='\"') ) {
                                    alt17=2;
                                }
                                else if ( ((LA17_3 >= '\u0000' && LA17_3 <= '!')||(LA17_3 >= '#' && LA17_3 <= '\uFFFF')) ) {
                                    alt17=1;
                                }


                            }
                            else if ( ((LA17_1 >= '\u0000' && LA17_1 <= '!')||(LA17_1 >= '#' && LA17_1 <= '\uFFFF')) ) {
                                alt17=1;
                            }


                        }
                        else if ( ((LA17_0 >= '\u0000' && LA17_0 <= '!')||(LA17_0 >= '#' && LA17_0 <= '\uFFFF')) ) {
                            alt17=1;
                        }


                        switch (alt17) {
                    	case 1 :
                    	    // Python.g:548:44: .
                    	    {
                    	    matchAny(); 

                    	    }
                    	    break;

                    	default :
                    	    break loop17;
                        }
                    } while (true);


                    match("\"\"\""); 



                    }
                    break;
                case 3 :
                    // Python.g:549:13: '\"' ( ESC |~ ( '\\\\' | '\\n' | '\"' ) )* '\"'
                    {
                    match('\"'); 

                    // Python.g:549:17: ( ESC |~ ( '\\\\' | '\\n' | '\"' ) )*
                    loop18:
                    do {
                        int alt18=3;
                        int LA18_0 = input.LA(1);

                        if ( (LA18_0=='\\') ) {
                            alt18=1;
                        }
                        else if ( ((LA18_0 >= '\u0000' && LA18_0 <= '\t')||(LA18_0 >= '\u000B' && LA18_0 <= '!')||(LA18_0 >= '#' && LA18_0 <= '[')||(LA18_0 >= ']' && LA18_0 <= '\uFFFF')) ) {
                            alt18=2;
                        }


                        switch (alt18) {
                    	case 1 :
                    	    // Python.g:549:18: ESC
                    	    {
                    	    mESC(); 


                    	    }
                    	    break;
                    	case 2 :
                    	    // Python.g:549:22: ~ ( '\\\\' | '\\n' | '\"' )
                    	    {
                    	    if ( (input.LA(1) >= '\u0000' && input.LA(1) <= '\t')||(input.LA(1) >= '\u000B' && input.LA(1) <= '!')||(input.LA(1) >= '#' && input.LA(1) <= '[')||(input.LA(1) >= ']' && input.LA(1) <= '\uFFFF') ) {
                    	        input.consume();
                    	    }
                    	    else {
                    	        MismatchedSetException mse = new MismatchedSetException(null,input);
                    	        recover(mse);
                    	        throw mse;
                    	    }


                    	    }
                    	    break;

                    	default :
                    	    break loop18;
                        }
                    } while (true);


                    match('\"'); 

                    }
                    break;
                case 4 :
                    // Python.g:550:13: '\\'' ( ESC |~ ( '\\\\' | '\\n' | '\\'' ) )* '\\''
                    {
                    match('\''); 

                    // Python.g:550:18: ( ESC |~ ( '\\\\' | '\\n' | '\\'' ) )*
                    loop19:
                    do {
                        int alt19=3;
                        int LA19_0 = input.LA(1);

                        if ( (LA19_0=='\\') ) {
                            alt19=1;
                        }
                        else if ( ((LA19_0 >= '\u0000' && LA19_0 <= '\t')||(LA19_0 >= '\u000B' && LA19_0 <= '&')||(LA19_0 >= '(' && LA19_0 <= '[')||(LA19_0 >= ']' && LA19_0 <= '\uFFFF')) ) {
                            alt19=2;
                        }


                        switch (alt19) {
                    	case 1 :
                    	    // Python.g:550:19: ESC
                    	    {
                    	    mESC(); 


                    	    }
                    	    break;
                    	case 2 :
                    	    // Python.g:550:23: ~ ( '\\\\' | '\\n' | '\\'' )
                    	    {
                    	    if ( (input.LA(1) >= '\u0000' && input.LA(1) <= '\t')||(input.LA(1) >= '\u000B' && input.LA(1) <= '&')||(input.LA(1) >= '(' && input.LA(1) <= '[')||(input.LA(1) >= ']' && input.LA(1) <= '\uFFFF') ) {
                    	        input.consume();
                    	    }
                    	    else {
                    	        MismatchedSetException mse = new MismatchedSetException(null,input);
                    	        recover(mse);
                    	        throw mse;
                    	    }


                    	    }
                    	    break;

                    	default :
                    	    break loop19;
                        }
                    } while (true);


                    match('\''); 

                    }
                    break;

            }


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "STRING"

    // $ANTLR start "ESC"
    public final void mESC() throws RecognitionException {
        try {
            // Python.g:554:2: ( '\\\\' . )
            // Python.g:554:4: '\\\\' .
            {
            match('\\'); 

            matchAny(); 

            }


        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "ESC"

    // $ANTLR start "CONTINUED_LINE"
    public final void mCONTINUED_LINE() throws RecognitionException {
        try {
            int _type = CONTINUED_LINE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:559:2: ( '\\\\' ( '\\r' )? '\\n' ( ' ' | '\\t' )* )
            // Python.g:559:4: '\\\\' ( '\\r' )? '\\n' ( ' ' | '\\t' )*
            {
            match('\\'); 

            // Python.g:559:9: ( '\\r' )?
            int alt21=2;
            int LA21_0 = input.LA(1);

            if ( (LA21_0=='\r') ) {
                alt21=1;
            }
            switch (alt21) {
                case 1 :
                    // Python.g:559:10: '\\r'
                    {
                    match('\r'); 

                    }
                    break;

            }


            match('\n'); 

            // Python.g:559:22: ( ' ' | '\\t' )*
            loop22:
            do {
                int alt22=2;
                int LA22_0 = input.LA(1);

                if ( (LA22_0=='\t'||LA22_0==' ') ) {
                    alt22=1;
                }


                switch (alt22) {
            	case 1 :
            	    // Python.g:
            	    {
            	    if ( input.LA(1)=='\t'||input.LA(1)==' ' ) {
            	        input.consume();
            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;
            	    }


            	    }
            	    break;

            	default :
            	    break loop22;
                }
            } while (true);


             _channel=HIDDEN; 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "CONTINUED_LINE"

    // $ANTLR start "NEWLINE"
    public final void mNEWLINE() throws RecognitionException {
        try {
            int _type = NEWLINE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:570:5: ( ( ( '\\r' )? '\\n' )+ )
            // Python.g:570:9: ( ( '\\r' )? '\\n' )+
            {
            // Python.g:570:9: ( ( '\\r' )? '\\n' )+
            int cnt24=0;
            loop24:
            do {
                int alt24=2;
                int LA24_0 = input.LA(1);

                if ( (LA24_0=='\n'||LA24_0=='\r') ) {
                    alt24=1;
                }


                switch (alt24) {
            	case 1 :
            	    // Python.g:570:10: ( '\\r' )? '\\n'
            	    {
            	    // Python.g:570:10: ( '\\r' )?
            	    int alt23=2;
            	    int LA23_0 = input.LA(1);

            	    if ( (LA23_0=='\r') ) {
            	        alt23=1;
            	    }
            	    switch (alt23) {
            	        case 1 :
            	            // Python.g:570:11: '\\r'
            	            {
            	            match('\r'); 

            	            }
            	            break;

            	    }


            	    match('\n'); 

            	    }
            	    break;

            	default :
            	    if ( cnt24 >= 1 ) break loop24;
                        EarlyExitException eee =
                            new EarlyExitException(24, input);
                        throw eee;
                }
                cnt24++;
            } while (true);


            if ( startPos==0 || implicitLineJoiningLevel>0 )
                        _channel=HIDDEN;
                    

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "NEWLINE"

    // $ANTLR start "WS"
    public final void mWS() throws RecognitionException {
        try {
            int _type = WS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // Python.g:572:4: ({...}? => ( ' ' | '\\t' )+ )
            // Python.g:572:6: {...}? => ( ' ' | '\\t' )+
            {
            if ( !((startPos>0)) ) {
                throw new FailedPredicateException(input, "WS", "startPos>0");
            }

            // Python.g:572:22: ( ' ' | '\\t' )+
            int cnt25=0;
            loop25:
            do {
                int alt25=2;
                int LA25_0 = input.LA(1);

                if ( (LA25_0=='\t'||LA25_0==' ') ) {
                    alt25=1;
                }


                switch (alt25) {
            	case 1 :
            	    // Python.g:
            	    {
            	    if ( input.LA(1)=='\t'||input.LA(1)==' ' ) {
            	        input.consume();
            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;
            	    }


            	    }
            	    break;

            	default :
            	    if ( cnt25 >= 1 ) break loop25;
                        EarlyExitException eee =
                            new EarlyExitException(25, input);
                        throw eee;
                }
                cnt25++;
            } while (true);


            _channel=HIDDEN;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "WS"

    // $ANTLR start "LEADING_WS"
    public final void mLEADING_WS() throws RecognitionException {
        try {
            int _type = LEADING_WS;
            int _channel = DEFAULT_TOKEN_CHANNEL;

                int spaces = 0;

            // Python.g:591:5: ({...}? => ({...}? ( ' ' | '\\t' )+ | ( ' ' | '\\t' )+ ( ( '\\r' )? '\\n' )* ) )
            // Python.g:591:9: {...}? => ({...}? ( ' ' | '\\t' )+ | ( ' ' | '\\t' )+ ( ( '\\r' )? '\\n' )* )
            {
            if ( !((startPos==0)) ) {
                throw new FailedPredicateException(input, "LEADING_WS", "startPos==0");
            }

            // Python.g:592:6: ({...}? ( ' ' | '\\t' )+ | ( ' ' | '\\t' )+ ( ( '\\r' )? '\\n' )* )
            int alt30=2;
            int LA30_0 = input.LA(1);

            if ( (LA30_0==' ') ) {
                int LA30_1 = input.LA(2);

                if ( ((implicitLineJoiningLevel>0)) ) {
                    alt30=1;
                }
                else if ( (true) ) {
                    alt30=2;
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 30, 1, input);

                    throw nvae;

                }
            }
            else if ( (LA30_0=='\t') ) {
                int LA30_2 = input.LA(2);

                if ( ((implicitLineJoiningLevel>0)) ) {
                    alt30=1;
                }
                else if ( (true) ) {
                    alt30=2;
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 30, 2, input);

                    throw nvae;

                }
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 30, 0, input);

                throw nvae;

            }
            switch (alt30) {
                case 1 :
                    // Python.g:592:10: {...}? ( ' ' | '\\t' )+
                    {
                    if ( !((implicitLineJoiningLevel>0)) ) {
                        throw new FailedPredicateException(input, "LEADING_WS", "implicitLineJoiningLevel>0");
                    }

                    // Python.g:592:40: ( ' ' | '\\t' )+
                    int cnt26=0;
                    loop26:
                    do {
                        int alt26=2;
                        int LA26_0 = input.LA(1);

                        if ( (LA26_0=='\t'||LA26_0==' ') ) {
                            alt26=1;
                        }


                        switch (alt26) {
                    	case 1 :
                    	    // Python.g:
                    	    {
                    	    if ( input.LA(1)=='\t'||input.LA(1)==' ' ) {
                    	        input.consume();
                    	    }
                    	    else {
                    	        MismatchedSetException mse = new MismatchedSetException(null,input);
                    	        recover(mse);
                    	        throw mse;
                    	    }


                    	    }
                    	    break;

                    	default :
                    	    if ( cnt26 >= 1 ) break loop26;
                                EarlyExitException eee =
                                    new EarlyExitException(26, input);
                                throw eee;
                        }
                        cnt26++;
                    } while (true);


                    _channel=HIDDEN;

                    }
                    break;
                case 2 :
                    // Python.g:593:11: ( ' ' | '\\t' )+ ( ( '\\r' )? '\\n' )*
                    {
                    // Python.g:593:11: ( ' ' | '\\t' )+
                    int cnt27=0;
                    loop27:
                    do {
                        int alt27=3;
                        int LA27_0 = input.LA(1);

                        if ( (LA27_0==' ') ) {
                            alt27=1;
                        }
                        else if ( (LA27_0=='\t') ) {
                            alt27=2;
                        }


                        switch (alt27) {
                    	case 1 :
                    	    // Python.g:593:14: ' '
                    	    {
                    	    match(' '); 

                    	     spaces++; 

                    	    }
                    	    break;
                    	case 2 :
                    	    // Python.g:594:12: '\\t'
                    	    {
                    	    match('\t'); 

                    	     spaces += 8; spaces -= (spaces % 8); 

                    	    }
                    	    break;

                    	default :
                    	    if ( cnt27 >= 1 ) break loop27;
                                EarlyExitException eee =
                                    new EarlyExitException(27, input);
                                throw eee;
                        }
                        cnt27++;
                    } while (true);



                                // make a string of n spaces where n is column number - 1
                                char[] indentation = new char[spaces];
                                for (int i=0; i<spaces; i++) {
                                    indentation[i] = ' ';
                                }
                                String s = new String(indentation);
                                emit(new ClassicToken(LEADING_WS,new String(indentation)));
                            	

                    // Python.g:606:10: ( ( '\\r' )? '\\n' )*
                    loop29:
                    do {
                        int alt29=2;
                        int LA29_0 = input.LA(1);

                        if ( (LA29_0=='\n'||LA29_0=='\r') ) {
                            alt29=1;
                        }


                        switch (alt29) {
                    	case 1 :
                    	    // Python.g:606:12: ( '\\r' )? '\\n'
                    	    {
                    	    // Python.g:606:12: ( '\\r' )?
                    	    int alt28=2;
                    	    int LA28_0 = input.LA(1);

                    	    if ( (LA28_0=='\r') ) {
                    	        alt28=1;
                    	    }
                    	    switch (alt28) {
                    	        case 1 :
                    	            // Python.g:606:13: '\\r'
                    	            {
                    	            match('\r'); 

                    	            }
                    	            break;

                    	    }


                    	    match('\n'); 

                    	    if (state.token!=null) state.token.setChannel(HIDDEN); else _channel=HIDDEN;

                    	    }
                    	    break;

                    	default :
                    	    break loop29;
                        }
                    } while (true);


                    }
                    break;

            }


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "LEADING_WS"

    // $ANTLR start "COMMENT"
    public final void mCOMMENT() throws RecognitionException {
        try {
            int _type = COMMENT;
            int _channel = DEFAULT_TOKEN_CHANNEL;

                _channel=HIDDEN;

            // Python.g:643:5: ({...}? => ( ' ' | '\\t' )* '#' (~ '\\n' )* ( '\\n' )+ |{...}? => '#' (~ '\\n' )* )
            int alt35=2;
            alt35 = dfa35.predict(input);
            switch (alt35) {
                case 1 :
                    // Python.g:643:7: {...}? => ( ' ' | '\\t' )* '#' (~ '\\n' )* ( '\\n' )+
                    {
                    if ( !((startPos==0)) ) {
                        throw new FailedPredicateException(input, "COMMENT", "startPos==0");
                    }

                    // Python.g:643:24: ( ' ' | '\\t' )*
                    loop31:
                    do {
                        int alt31=2;
                        int LA31_0 = input.LA(1);

                        if ( (LA31_0=='\t'||LA31_0==' ') ) {
                            alt31=1;
                        }


                        switch (alt31) {
                    	case 1 :
                    	    // Python.g:
                    	    {
                    	    if ( input.LA(1)=='\t'||input.LA(1)==' ' ) {
                    	        input.consume();
                    	    }
                    	    else {
                    	        MismatchedSetException mse = new MismatchedSetException(null,input);
                    	        recover(mse);
                    	        throw mse;
                    	    }


                    	    }
                    	    break;

                    	default :
                    	    break loop31;
                        }
                    } while (true);


                    match('#'); 

                    // Python.g:643:40: (~ '\\n' )*
                    loop32:
                    do {
                        int alt32=2;
                        int LA32_0 = input.LA(1);

                        if ( ((LA32_0 >= '\u0000' && LA32_0 <= '\t')||(LA32_0 >= '\u000B' && LA32_0 <= '\uFFFF')) ) {
                            alt32=1;
                        }


                        switch (alt32) {
                    	case 1 :
                    	    // Python.g:
                    	    {
                    	    if ( (input.LA(1) >= '\u0000' && input.LA(1) <= '\t')||(input.LA(1) >= '\u000B' && input.LA(1) <= '\uFFFF') ) {
                    	        input.consume();
                    	    }
                    	    else {
                    	        MismatchedSetException mse = new MismatchedSetException(null,input);
                    	        recover(mse);
                    	        throw mse;
                    	    }


                    	    }
                    	    break;

                    	default :
                    	    break loop32;
                        }
                    } while (true);


                    // Python.g:643:49: ( '\\n' )+
                    int cnt33=0;
                    loop33:
                    do {
                        int alt33=2;
                        int LA33_0 = input.LA(1);

                        if ( (LA33_0=='\n') ) {
                            alt33=1;
                        }


                        switch (alt33) {
                    	case 1 :
                    	    // Python.g:643:49: '\\n'
                    	    {
                    	    match('\n'); 

                    	    }
                    	    break;

                    	default :
                    	    if ( cnt33 >= 1 ) break loop33;
                                EarlyExitException eee =
                                    new EarlyExitException(33, input);
                                throw eee;
                        }
                        cnt33++;
                    } while (true);


                    }
                    break;
                case 2 :
                    // Python.g:644:7: {...}? => '#' (~ '\\n' )*
                    {
                    if ( !((startPos>0)) ) {
                        throw new FailedPredicateException(input, "COMMENT", "startPos>0");
                    }

                    match('#'); 

                    // Python.g:644:27: (~ '\\n' )*
                    loop34:
                    do {
                        int alt34=2;
                        int LA34_0 = input.LA(1);

                        if ( ((LA34_0 >= '\u0000' && LA34_0 <= '\t')||(LA34_0 >= '\u000B' && LA34_0 <= '\uFFFF')) ) {
                            alt34=1;
                        }


                        switch (alt34) {
                    	case 1 :
                    	    // Python.g:
                    	    {
                    	    if ( (input.LA(1) >= '\u0000' && input.LA(1) <= '\t')||(input.LA(1) >= '\u000B' && input.LA(1) <= '\uFFFF') ) {
                    	        input.consume();
                    	    }
                    	    else {
                    	        MismatchedSetException mse = new MismatchedSetException(null,input);
                    	        recover(mse);
                    	        throw mse;
                    	    }


                    	    }
                    	    break;

                    	default :
                    	    break loop34;
                        }
                    } while (true);


                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "COMMENT"

    public void mTokens() throws RecognitionException {
        // Python.g:1:8: ( T__84 | T__85 | T__86 | T__87 | T__88 | T__89 | T__90 | T__91 | T__92 | T__93 | T__94 | T__95 | T__96 | T__97 | T__98 | T__99 | T__100 | T__101 | T__102 | T__103 | T__104 | T__105 | T__106 | T__107 | T__108 | T__109 | T__110 | T__111 | T__112 | LPAREN | RPAREN | LBRACK | RBRACK | COLON | COMMA | SEMI | PLUS | MINUS | STAR | SLASH | VBAR | AMPER | LESS | GREATER | ASSIGN | PERCENT | BACKQUOTE | LCURLY | RCURLY | CIRCUMFLEX | TILDE | EQUAL | NOTEQUAL | ALT_NOTEQUAL | LESSEQUAL | LEFTSHIFT | GREATEREQUAL | RIGHTSHIFT | PLUSEQUAL | MINUSEQUAL | DOUBLESTAR | STAREQUAL | DOUBLESLASH | SLASHEQUAL | VBAREQUAL | PERCENTEQUAL | AMPEREQUAL | CIRCUMFLEXEQUAL | LEFTSHIFTEQUAL | RIGHTSHIFTEQUAL | DOUBLESTAREQUAL | DOUBLESLASHEQUAL | DOT | FLOAT | LONGINT | INT | COMPLEX | NAME | STRING | CONTINUED_LINE | NEWLINE | WS | LEADING_WS | COMMENT )
        int alt36=84;
        alt36 = dfa36.predict(input);
        switch (alt36) {
            case 1 :
                // Python.g:1:10: T__84
                {
                mT__84(); 


                }
                break;
            case 2 :
                // Python.g:1:16: T__85
                {
                mT__85(); 


                }
                break;
            case 3 :
                // Python.g:1:22: T__86
                {
                mT__86(); 


                }
                break;
            case 4 :
                // Python.g:1:28: T__87
                {
                mT__87(); 


                }
                break;
            case 5 :
                // Python.g:1:34: T__88
                {
                mT__88(); 


                }
                break;
            case 6 :
                // Python.g:1:40: T__89
                {
                mT__89(); 


                }
                break;
            case 7 :
                // Python.g:1:46: T__90
                {
                mT__90(); 


                }
                break;
            case 8 :
                // Python.g:1:52: T__91
                {
                mT__91(); 


                }
                break;
            case 9 :
                // Python.g:1:58: T__92
                {
                mT__92(); 


                }
                break;
            case 10 :
                // Python.g:1:64: T__93
                {
                mT__93(); 


                }
                break;
            case 11 :
                // Python.g:1:70: T__94
                {
                mT__94(); 


                }
                break;
            case 12 :
                // Python.g:1:76: T__95
                {
                mT__95(); 


                }
                break;
            case 13 :
                // Python.g:1:82: T__96
                {
                mT__96(); 


                }
                break;
            case 14 :
                // Python.g:1:88: T__97
                {
                mT__97(); 


                }
                break;
            case 15 :
                // Python.g:1:94: T__98
                {
                mT__98(); 


                }
                break;
            case 16 :
                // Python.g:1:100: T__99
                {
                mT__99(); 


                }
                break;
            case 17 :
                // Python.g:1:106: T__100
                {
                mT__100(); 


                }
                break;
            case 18 :
                // Python.g:1:113: T__101
                {
                mT__101(); 


                }
                break;
            case 19 :
                // Python.g:1:120: T__102
                {
                mT__102(); 


                }
                break;
            case 20 :
                // Python.g:1:127: T__103
                {
                mT__103(); 


                }
                break;
            case 21 :
                // Python.g:1:134: T__104
                {
                mT__104(); 


                }
                break;
            case 22 :
                // Python.g:1:141: T__105
                {
                mT__105(); 


                }
                break;
            case 23 :
                // Python.g:1:148: T__106
                {
                mT__106(); 


                }
                break;
            case 24 :
                // Python.g:1:155: T__107
                {
                mT__107(); 


                }
                break;
            case 25 :
                // Python.g:1:162: T__108
                {
                mT__108(); 


                }
                break;
            case 26 :
                // Python.g:1:169: T__109
                {
                mT__109(); 


                }
                break;
            case 27 :
                // Python.g:1:176: T__110
                {
                mT__110(); 


                }
                break;
            case 28 :
                // Python.g:1:183: T__111
                {
                mT__111(); 


                }
                break;
            case 29 :
                // Python.g:1:190: T__112
                {
                mT__112(); 


                }
                break;
            case 30 :
                // Python.g:1:197: LPAREN
                {
                mLPAREN(); 


                }
                break;
            case 31 :
                // Python.g:1:204: RPAREN
                {
                mRPAREN(); 


                }
                break;
            case 32 :
                // Python.g:1:211: LBRACK
                {
                mLBRACK(); 


                }
                break;
            case 33 :
                // Python.g:1:218: RBRACK
                {
                mRBRACK(); 


                }
                break;
            case 34 :
                // Python.g:1:225: COLON
                {
                mCOLON(); 


                }
                break;
            case 35 :
                // Python.g:1:231: COMMA
                {
                mCOMMA(); 


                }
                break;
            case 36 :
                // Python.g:1:237: SEMI
                {
                mSEMI(); 


                }
                break;
            case 37 :
                // Python.g:1:242: PLUS
                {
                mPLUS(); 


                }
                break;
            case 38 :
                // Python.g:1:247: MINUS
                {
                mMINUS(); 


                }
                break;
            case 39 :
                // Python.g:1:253: STAR
                {
                mSTAR(); 


                }
                break;
            case 40 :
                // Python.g:1:258: SLASH
                {
                mSLASH(); 


                }
                break;
            case 41 :
                // Python.g:1:264: VBAR
                {
                mVBAR(); 


                }
                break;
            case 42 :
                // Python.g:1:269: AMPER
                {
                mAMPER(); 


                }
                break;
            case 43 :
                // Python.g:1:275: LESS
                {
                mLESS(); 


                }
                break;
            case 44 :
                // Python.g:1:280: GREATER
                {
                mGREATER(); 


                }
                break;
            case 45 :
                // Python.g:1:288: ASSIGN
                {
                mASSIGN(); 


                }
                break;
            case 46 :
                // Python.g:1:295: PERCENT
                {
                mPERCENT(); 


                }
                break;
            case 47 :
                // Python.g:1:303: BACKQUOTE
                {
                mBACKQUOTE(); 


                }
                break;
            case 48 :
                // Python.g:1:313: LCURLY
                {
                mLCURLY(); 


                }
                break;
            case 49 :
                // Python.g:1:320: RCURLY
                {
                mRCURLY(); 


                }
                break;
            case 50 :
                // Python.g:1:327: CIRCUMFLEX
                {
                mCIRCUMFLEX(); 


                }
                break;
            case 51 :
                // Python.g:1:338: TILDE
                {
                mTILDE(); 


                }
                break;
            case 52 :
                // Python.g:1:344: EQUAL
                {
                mEQUAL(); 


                }
                break;
            case 53 :
                // Python.g:1:350: NOTEQUAL
                {
                mNOTEQUAL(); 


                }
                break;
            case 54 :
                // Python.g:1:359: ALT_NOTEQUAL
                {
                mALT_NOTEQUAL(); 


                }
                break;
            case 55 :
                // Python.g:1:372: LESSEQUAL
                {
                mLESSEQUAL(); 


                }
                break;
            case 56 :
                // Python.g:1:382: LEFTSHIFT
                {
                mLEFTSHIFT(); 


                }
                break;
            case 57 :
                // Python.g:1:392: GREATEREQUAL
                {
                mGREATEREQUAL(); 


                }
                break;
            case 58 :
                // Python.g:1:405: RIGHTSHIFT
                {
                mRIGHTSHIFT(); 


                }
                break;
            case 59 :
                // Python.g:1:416: PLUSEQUAL
                {
                mPLUSEQUAL(); 


                }
                break;
            case 60 :
                // Python.g:1:426: MINUSEQUAL
                {
                mMINUSEQUAL(); 


                }
                break;
            case 61 :
                // Python.g:1:437: DOUBLESTAR
                {
                mDOUBLESTAR(); 


                }
                break;
            case 62 :
                // Python.g:1:448: STAREQUAL
                {
                mSTAREQUAL(); 


                }
                break;
            case 63 :
                // Python.g:1:458: DOUBLESLASH
                {
                mDOUBLESLASH(); 


                }
                break;
            case 64 :
                // Python.g:1:470: SLASHEQUAL
                {
                mSLASHEQUAL(); 


                }
                break;
            case 65 :
                // Python.g:1:481: VBAREQUAL
                {
                mVBAREQUAL(); 


                }
                break;
            case 66 :
                // Python.g:1:491: PERCENTEQUAL
                {
                mPERCENTEQUAL(); 


                }
                break;
            case 67 :
                // Python.g:1:504: AMPEREQUAL
                {
                mAMPEREQUAL(); 


                }
                break;
            case 68 :
                // Python.g:1:515: CIRCUMFLEXEQUAL
                {
                mCIRCUMFLEXEQUAL(); 


                }
                break;
            case 69 :
                // Python.g:1:531: LEFTSHIFTEQUAL
                {
                mLEFTSHIFTEQUAL(); 


                }
                break;
            case 70 :
                // Python.g:1:546: RIGHTSHIFTEQUAL
                {
                mRIGHTSHIFTEQUAL(); 


                }
                break;
            case 71 :
                // Python.g:1:562: DOUBLESTAREQUAL
                {
                mDOUBLESTAREQUAL(); 


                }
                break;
            case 72 :
                // Python.g:1:578: DOUBLESLASHEQUAL
                {
                mDOUBLESLASHEQUAL(); 


                }
                break;
            case 73 :
                // Python.g:1:595: DOT
                {
                mDOT(); 


                }
                break;
            case 74 :
                // Python.g:1:599: FLOAT
                {
                mFLOAT(); 


                }
                break;
            case 75 :
                // Python.g:1:605: LONGINT
                {
                mLONGINT(); 


                }
                break;
            case 76 :
                // Python.g:1:613: INT
                {
                mINT(); 


                }
                break;
            case 77 :
                // Python.g:1:617: COMPLEX
                {
                mCOMPLEX(); 


                }
                break;
            case 78 :
                // Python.g:1:625: NAME
                {
                mNAME(); 


                }
                break;
            case 79 :
                // Python.g:1:630: STRING
                {
                mSTRING(); 


                }
                break;
            case 80 :
                // Python.g:1:637: CONTINUED_LINE
                {
                mCONTINUED_LINE(); 


                }
                break;
            case 81 :
                // Python.g:1:652: NEWLINE
                {
                mNEWLINE(); 


                }
                break;
            case 82 :
                // Python.g:1:660: WS
                {
                mWS(); 


                }
                break;
            case 83 :
                // Python.g:1:663: LEADING_WS
                {
                mLEADING_WS(); 


                }
                break;
            case 84 :
                // Python.g:1:674: COMMENT
                {
                mCOMMENT(); 


                }
                break;

        }

    }


    protected DFA12 dfa12 = new DFA12(this);
    protected DFA35 dfa35 = new DFA35(this);
    protected DFA36 dfa36 = new DFA36(this);
    static final String DFA12_eotS =
        "\7\uffff";
    static final String DFA12_eofS =
        "\7\uffff";
    static final String DFA12_minS =
        "\3\56\2\uffff\2\56";
    static final String DFA12_maxS =
        "\1\71\1\170\1\152\2\uffff\2\152";
    static final String DFA12_acceptS =
        "\3\uffff\1\2\1\1\2\uffff";
    static final String DFA12_specialS =
        "\7\uffff}>";
    static final String[] DFA12_transitionS = {
            "\1\3\1\uffff\1\1\11\2",
            "\1\3\1\uffff\12\5\13\uffff\1\3\4\uffff\1\4\15\uffff\1\4\14"+
            "\uffff\1\3\4\uffff\1\4\15\uffff\1\4",
            "\1\3\1\uffff\12\6\13\uffff\1\3\4\uffff\1\4\32\uffff\1\3\4\uffff"+
            "\1\4",
            "",
            "",
            "\1\3\1\uffff\12\5\13\uffff\1\3\4\uffff\1\4\32\uffff\1\3\4\uffff"+
            "\1\4",
            "\1\3\1\uffff\12\6\13\uffff\1\3\4\uffff\1\4\32\uffff\1\3\4\uffff"+
            "\1\4"
    };

    static final short[] DFA12_eot = DFA.unpackEncodedString(DFA12_eotS);
    static final short[] DFA12_eof = DFA.unpackEncodedString(DFA12_eofS);
    static final char[] DFA12_min = DFA.unpackEncodedStringToUnsignedChars(DFA12_minS);
    static final char[] DFA12_max = DFA.unpackEncodedStringToUnsignedChars(DFA12_maxS);
    static final short[] DFA12_accept = DFA.unpackEncodedString(DFA12_acceptS);
    static final short[] DFA12_special = DFA.unpackEncodedString(DFA12_specialS);
    static final short[][] DFA12_transition;

    static {
        int numStates = DFA12_transitionS.length;
        DFA12_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA12_transition[i] = DFA.unpackEncodedString(DFA12_transitionS[i]);
        }
    }

    class DFA12 extends DFA {

        public DFA12(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 12;
            this.eot = DFA12_eot;
            this.eof = DFA12_eof;
            this.min = DFA12_min;
            this.max = DFA12_max;
            this.accept = DFA12_accept;
            this.special = DFA12_special;
            this.transition = DFA12_transition;
        }
        public String getDescription() {
            return "527:1: COMPLEX : ( INT ( 'j' | 'J' ) | FLOAT ( 'j' | 'J' ) );";
        }
    }
    static final String DFA35_eotS =
        "\2\uffff\2\4\1\uffff";
    static final String DFA35_eofS =
        "\5\uffff";
    static final String DFA35_minS =
        "\1\11\1\uffff\2\0\1\uffff";
    static final String DFA35_maxS =
        "\1\43\1\uffff\2\uffff\1\uffff";
    static final String DFA35_acceptS =
        "\1\uffff\1\1\2\uffff\1\2";
    static final String DFA35_specialS =
        "\1\2\1\uffff\1\0\1\1\1\uffff}>";
    static final String[] DFA35_transitionS = {
            "\1\1\26\uffff\1\1\2\uffff\1\2",
            "",
            "\12\3\1\1\ufff5\3",
            "\12\3\1\1\ufff5\3",
            ""
    };

    static final short[] DFA35_eot = DFA.unpackEncodedString(DFA35_eotS);
    static final short[] DFA35_eof = DFA.unpackEncodedString(DFA35_eofS);
    static final char[] DFA35_min = DFA.unpackEncodedStringToUnsignedChars(DFA35_minS);
    static final char[] DFA35_max = DFA.unpackEncodedStringToUnsignedChars(DFA35_maxS);
    static final short[] DFA35_accept = DFA.unpackEncodedString(DFA35_acceptS);
    static final short[] DFA35_special = DFA.unpackEncodedString(DFA35_specialS);
    static final short[][] DFA35_transition;

    static {
        int numStates = DFA35_transitionS.length;
        DFA35_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA35_transition[i] = DFA.unpackEncodedString(DFA35_transitionS[i]);
        }
    }

    class DFA35 extends DFA {

        public DFA35(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 35;
            this.eot = DFA35_eot;
            this.eof = DFA35_eof;
            this.min = DFA35_min;
            this.max = DFA35_max;
            this.accept = DFA35_accept;
            this.special = DFA35_special;
            this.transition = DFA35_transition;
        }
        public String getDescription() {
            return "639:1: COMMENT : ({...}? => ( ' ' | '\\t' )* '#' (~ '\\n' )* ( '\\n' )+ |{...}? => '#' (~ '\\n' )* );";
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            IntStream input = _input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA35_2 = input.LA(1);

                         
                        int index35_2 = input.index();
                        input.rewind();

                        s = -1;
                        if ( ((LA35_2 >= '\u0000' && LA35_2 <= '\t')||(LA35_2 >= '\u000B' && LA35_2 <= '\uFFFF')) && (((startPos==0)||(startPos>0)))) {s = 3;}

                        else if ( (LA35_2=='\n') && ((startPos==0))) {s = 1;}

                        else s = 4;

                         
                        input.seek(index35_2);

                        if ( s>=0 ) return s;
                        break;

                    case 1 : 
                        int LA35_3 = input.LA(1);

                         
                        int index35_3 = input.index();
                        input.rewind();

                        s = -1;
                        if ( (LA35_3=='\n') && ((startPos==0))) {s = 1;}

                        else if ( ((LA35_3 >= '\u0000' && LA35_3 <= '\t')||(LA35_3 >= '\u000B' && LA35_3 <= '\uFFFF')) && (((startPos==0)||(startPos>0)))) {s = 3;}

                        else s = 4;

                         
                        input.seek(index35_3);

                        if ( s>=0 ) return s;
                        break;

                    case 2 : 
                        int LA35_0 = input.LA(1);

                         
                        int index35_0 = input.index();
                        input.rewind();

                        s = -1;
                        if ( (LA35_0=='\t'||LA35_0==' ') && ((startPos==0))) {s = 1;}

                        else if ( (LA35_0=='#') && (((startPos==0)||(startPos>0)))) {s = 2;}

                         
                        input.seek(index35_0);

                        if ( s>=0 ) return s;
                        break;
            }
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 35, _s, input);
            error(nvae);
            throw nvae;
        }

    }
    static final String DFA36_eotS =
        "\1\uffff\20\54\7\uffff\1\116\1\120\1\123\1\126\1\130\1\132\1\136"+
        "\1\141\1\143\1\145\3\uffff\1\147\2\uffff\1\150\2\153\1\54\4\uffff"+
        "\2\163\1\uffff\14\54\1\u0085\1\54\1\u0087\1\u0088\2\54\1\u008b\7"+
        "\54\4\uffff\1\u0094\2\uffff\1\u0096\10\uffff\1\u0098\2\uffff\1\u009a"+
        "\10\uffff\1\u009b\2\uffff\1\u009b\1\uffff\1\153\2\uffff\1\153\1"+
        "\54\3\uffff\1\u00a2\4\54\1\u00a7\1\u00a8\5\54\1\u00ae\2\54\1\uffff"+
        "\1\54\2\uffff\1\54\1\u00b3\1\uffff\4\54\1\u00b8\2\54\12\uffff\1"+
        "\153\1\u009b\1\uffff\1\u009b\2\uffff\4\54\2\uffff\1\u00c3\1\u00c4"+
        "\1\54\1\u00c6\1\54\1\uffff\1\u00c8\3\54\1\uffff\1\u00cc\3\54\1\uffff"+
        "\2\54\1\uffff\1\u009b\1\157\1\uffff\1\54\1\u00d5\1\u00d6\1\54\2"+
        "\uffff\1\54\1\uffff\1\54\1\uffff\3\54\1\uffff\1\u00dd\1\u00de\1"+
        "\54\1\u00e0\1\u00e1\1\uffff\1\u009b\1\u00e2\2\uffff\1\54\1\u00e4"+
        "\1\54\1\u00e6\1\u00e7\1\u00e8\2\uffff\1\u00e9\3\uffff\1\54\1\uffff"+
        "\1\u00eb\4\uffff\1\u00ec\2\uffff";
    static final String DFA36_eofS =
        "\u00ed\uffff";
    static final String DFA36_minS =
        "\1\11\1\156\1\162\1\154\1\145\1\154\1\151\1\154\1\146\1\141\1\157"+
        "\1\162\1\141\1\42\1\162\1\150\1\151\7\uffff\2\75\1\52\1\57\2\75"+
        "\1\74\3\75\3\uffff\1\75\2\uffff\1\60\2\56\1\42\4\uffff\2\11\1\uffff"+
        "\1\144\1\163\1\145\1\141\1\156\1\146\1\151\1\143\1\156\1\162\2\157"+
        "\1\60\1\160\2\60\1\155\1\164\1\60\1\163\2\151\1\164\1\171\1\151"+
        "\1\145\4\uffff\1\75\2\uffff\1\75\10\uffff\1\75\2\uffff\1\75\10\uffff"+
        "\2\60\1\uffff\1\60\1\53\1\56\2\uffff\1\56\1\42\1\0\2\uffff\1\60"+
        "\1\145\1\141\1\163\1\164\2\60\1\146\2\145\1\143\1\141\1\60\1\155"+
        "\1\142\1\uffff\1\157\2\uffff\1\142\1\60\1\uffff\1\163\1\156\1\163"+
        "\1\165\1\60\2\154\11\uffff\1\53\4\60\2\uffff\1\162\1\153\1\163\1"+
        "\151\2\uffff\2\60\1\160\1\60\1\154\1\uffff\1\60\1\141\1\162\1\144"+
        "\1\uffff\1\60\1\164\1\145\1\162\1\uffff\1\145\1\144\2\60\1\112\1"+
        "\53\1\164\2\60\1\156\2\uffff\1\164\1\uffff\1\154\1\uffff\1\154\1"+
        "\164\1\141\1\uffff\2\60\1\156\5\60\2\uffff\1\165\1\60\1\171\3\60"+
        "\2\uffff\1\60\3\uffff\1\145\1\uffff\1\60\4\uffff\1\60\2\uffff";
    static final String DFA36_maxS =
        "\1\176\1\163\1\162\1\157\1\145\1\170\1\162\1\154\1\163\1\141\1\157"+
        "\2\162\1\145\1\162\1\150\1\151\7\uffff\6\75\2\76\2\75\3\uffff\1"+
        "\75\2\uffff\1\71\1\170\1\154\1\162\4\uffff\2\43\1\uffff\1\144\1"+
        "\163\1\145\1\141\1\156\1\154\1\163\1\145\1\156\1\162\2\157\1\172"+
        "\1\160\2\172\1\155\1\164\1\172\1\163\2\151\1\164\1\171\1\151\1\145"+
        "\4\uffff\1\75\2\uffff\1\75\10\uffff\1\75\2\uffff\1\75\10\uffff\1"+
        "\152\1\146\1\uffff\1\152\1\71\1\154\2\uffff\1\154\1\47\1\0\2\uffff"+
        "\1\172\1\145\1\141\1\163\1\164\2\172\1\146\2\145\1\143\1\141\1\172"+
        "\1\155\1\142\1\uffff\1\157\2\uffff\1\142\1\172\1\uffff\1\163\1\156"+
        "\1\163\1\165\1\172\2\154\11\uffff\1\71\1\154\1\152\1\71\1\152\2"+
        "\uffff\1\162\1\153\1\163\1\151\2\uffff\2\172\1\160\1\172\1\154\1"+
        "\uffff\1\172\1\141\1\162\1\144\1\uffff\1\172\1\164\1\145\1\162\1"+
        "\uffff\1\145\1\144\1\71\2\152\1\71\1\164\2\172\1\156\2\uffff\1\164"+
        "\1\uffff\1\154\1\uffff\1\154\1\164\1\141\1\uffff\2\172\1\156\2\172"+
        "\1\71\1\152\1\172\2\uffff\1\165\1\172\1\171\3\172\2\uffff\1\172"+
        "\3\uffff\1\145\1\uffff\1\172\4\uffff\1\172\2\uffff";
    static final String DFA36_acceptS =
        "\21\uffff\1\36\1\37\1\40\1\41\1\42\1\43\1\44\12\uffff\1\57\1\60"+
        "\1\61\1\uffff\1\63\1\65\4\uffff\1\116\1\117\1\120\1\121\2\uffff"+
        "\1\124\32\uffff\1\73\1\45\1\74\1\46\1\uffff\1\76\1\47\1\uffff\1"+
        "\100\1\50\1\101\1\51\1\103\1\52\1\66\1\67\1\uffff\1\53\1\71\1\uffff"+
        "\1\54\1\64\1\55\1\102\1\56\1\104\1\62\1\111\2\uffff\1\114\3\uffff"+
        "\1\113\1\115\3\uffff\1\123\1\124\17\uffff\1\20\1\uffff\1\22\1\23"+
        "\2\uffff\1\26\7\uffff\1\107\1\75\1\110\1\77\1\105\1\70\1\106\1\72"+
        "\1\112\5\uffff\1\122\1\1\4\uffff\1\6\1\7\5\uffff\1\15\4\uffff\1"+
        "\25\4\uffff\1\33\12\uffff\1\10\1\11\1\uffff\1\13\1\uffff\1\16\3"+
        "\uffff\1\27\10\uffff\1\3\1\4\6\uffff\1\30\1\31\1\uffff\1\34\1\35"+
        "\1\2\1\uffff\1\12\1\uffff\1\17\1\21\1\24\1\32\1\uffff\1\14\1\5";
    static final String DFA36_specialS =
        "\1\3\57\uffff\1\2\1\1\101\uffff\1\0\171\uffff}>";
    static final String[] DFA36_transitionS = {
            "\1\61\1\57\2\uffff\1\57\22\uffff\1\60\1\47\1\55\1\62\1\uffff"+
            "\1\41\1\35\1\55\1\21\1\22\1\32\1\30\1\26\1\31\1\50\1\33\1\51"+
            "\11\52\1\25\1\27\1\36\1\40\1\37\2\uffff\32\54\1\23\1\56\1\24"+
            "\1\45\1\54\1\42\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\54\1\10\2\54\1"+
            "\11\1\54\1\12\1\13\1\14\1\54\1\15\1\54\1\16\1\53\1\54\1\17\1"+
            "\54\1\20\1\54\1\43\1\34\1\44\1\46",
            "\1\63\4\uffff\1\64",
            "\1\65",
            "\1\66\2\uffff\1\67",
            "\1\70",
            "\1\71\13\uffff\1\72",
            "\1\73\5\uffff\1\74\2\uffff\1\75",
            "\1\76",
            "\1\77\6\uffff\1\100\1\101\4\uffff\1\102",
            "\1\103",
            "\1\104",
            "\1\105",
            "\1\106\20\uffff\1\107",
            "\1\55\4\uffff\1\55\71\uffff\1\110\3\uffff\1\111",
            "\1\112",
            "\1\113",
            "\1\114",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\115",
            "\1\117",
            "\1\121\22\uffff\1\122",
            "\1\124\15\uffff\1\125",
            "\1\127",
            "\1\131",
            "\1\135\1\134\1\133",
            "\1\137\1\140",
            "\1\142",
            "\1\144",
            "",
            "",
            "",
            "\1\146",
            "",
            "",
            "\12\151",
            "\1\154\1\uffff\12\156\13\uffff\1\155\4\uffff\1\160\1\uffff"+
            "\1\157\13\uffff\1\152\14\uffff\1\155\4\uffff\1\160\1\uffff\1"+
            "\157\13\uffff\1\152",
            "\1\154\1\uffff\12\161\13\uffff\1\155\4\uffff\1\160\1\uffff"+
            "\1\157\30\uffff\1\155\4\uffff\1\160\1\uffff\1\157",
            "\1\55\4\uffff\1\55\112\uffff\1\162",
            "",
            "",
            "",
            "",
            "\1\61\1\164\2\uffff\1\164\22\uffff\1\60\2\uffff\1\165",
            "\1\61\1\164\2\uffff\1\164\22\uffff\1\60\2\uffff\1\165",
            "",
            "\1\166",
            "\1\167",
            "\1\170",
            "\1\171",
            "\1\172",
            "\1\173\5\uffff\1\174",
            "\1\175\11\uffff\1\176",
            "\1\177\1\uffff\1\u0080",
            "\1\u0081",
            "\1\u0082",
            "\1\u0083",
            "\1\u0084",
            "\12\54\7\uffff\32\54\4\uffff\1\54\1\uffff\32\54",
            "\1\u0086",
            "\12\54\7\uffff\32\54\4\uffff\1\54\1\uffff\32\54",
            "\12\54\7\uffff\32\54\4\uffff\1\54\1\uffff\32\54",
            "\1\u0089",
            "\1\u008a",
            "\12\54\7\uffff\32\54\4\uffff\1\54\1\uffff\32\54",
            "\1\u008c",
            "\1\u008d",
            "\1\u008e",
            "\1\u008f",
            "\1\u0090",
            "\1\u0091",
            "\1\u0092",
            "",
            "",
            "",
            "",
            "\1\u0093",
            "",
            "",
            "\1\u0095",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\u0097",
            "",
            "",
            "\1\u0099",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\12\151\13\uffff\1\u009c\4\uffff\1\160\32\uffff\1\u009c\4\uffff"+
            "\1\160",
            "\12\u009d\7\uffff\6\u009d\32\uffff\6\u009d",
            "",
            "\12\u009e\20\uffff\1\160\37\uffff\1\160",
            "\1\u009f\1\uffff\1\u009f\2\uffff\12\u00a0",
            "\1\154\1\uffff\12\156\13\uffff\1\155\4\uffff\1\160\1\uffff"+
            "\1\157\30\uffff\1\155\4\uffff\1\160\1\uffff\1\157",
            "",
            "",
            "\1\154\1\uffff\12\161\13\uffff\1\155\4\uffff\1\160\1\uffff"+
            "\1\157\30\uffff\1\155\4\uffff\1\160\1\uffff\1\157",
            "\1\55\4\uffff\1\55",
            "\1\uffff",
            "",
            "",
            "\12\54\7\uffff\32\54\4\uffff\1\54\1\uffff\32\54",
            "\1\u00a3",
            "\1\u00a4",
            "\1\u00a5",
            "\1\u00a6",
            "\12\54\7\uffff\32\54\4\uffff\1\54\1\uffff\32\54",
            "\12\54\7\uffff\32\54\4\uffff\1\54\1\uffff\32\54",
            "\1\u00a9",
            "\1\u00aa",
            "\1\u00ab",
            "\1\u00ac",
            "\1\u00ad",
            "\12\54\7\uffff\32\54\4\uffff\1\54\1\uffff\32\54",
            "\1\u00af",
            "\1\u00b0",
            "",
            "\1\u00b1",
            "",
            "",
            "\1\u00b2",
            "\12\54\7\uffff\32\54\4\uffff\1\54\1\uffff\32\54",
            "",
            "\1\u00b4",
            "\1\u00b5",
            "\1\u00b6",
            "\1\u00b7",
            "\12\54\7\uffff\32\54\4\uffff\1\54\1\uffff\32\54",
            "\1\u00b9",
            "\1\u00ba",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\u00bb\1\uffff\1\u00bb\2\uffff\12\u00bc",
            "\12\u009d\7\uffff\6\u009d\3\uffff\1\160\1\uffff\1\u00bd\24"+
            "\uffff\6\u009d\3\uffff\1\160\1\uffff\1\u00bd",
            "\12\u009e\13\uffff\1\u00be\4\uffff\1\160\32\uffff\1\u00be\4"+
            "\uffff\1\160",
            "\12\u00a0",
            "\12\u00a0\20\uffff\1\160\37\uffff\1\160",
            "",
            "",
            "\1\u00bf",
            "\1\u00c0",
            "\1\u00c1",
            "\1\u00c2",
            "",
            "",
            "\12\54\7\uffff\32\54\4\uffff\1\54\1\uffff\32\54",
            "\12\54\7\uffff\32\54\4\uffff\1\54\1\uffff\32\54",
            "\1\u00c5",
            "\12\54\7\uffff\32\54\4\uffff\1\54\1\uffff\32\54",
            "\1\u00c7",
            "",
            "\12\54\7\uffff\32\54\4\uffff\1\54\1\uffff\32\54",
            "\1\u00c9",
            "\1\u00ca",
            "\1\u00cb",
            "",
            "\12\54\7\uffff\32\54\4\uffff\1\54\1\uffff\32\54",
            "\1\u00cd",
            "\1\u00ce",
            "\1\u00cf",
            "",
            "\1\u00d0",
            "\1\u00d1",
            "\12\u00bc",
            "\12\u00bc\20\uffff\1\160\37\uffff\1\160",
            "\1\160\37\uffff\1\160",
            "\1\u00d2\1\uffff\1\u00d2\2\uffff\12\u00d3",
            "\1\u00d4",
            "\12\54\7\uffff\32\54\4\uffff\1\54\1\uffff\32\54",
            "\12\54\7\uffff\32\54\4\uffff\1\54\1\uffff\32\54",
            "\1\u00d7",
            "",
            "",
            "\1\u00d8",
            "",
            "\1\u00d9",
            "",
            "\1\u00da",
            "\1\u00db",
            "\1\u00dc",
            "",
            "\12\54\7\uffff\32\54\4\uffff\1\54\1\uffff\32\54",
            "\12\54\7\uffff\32\54\4\uffff\1\54\1\uffff\32\54",
            "\1\u00df",
            "\12\54\7\uffff\32\54\4\uffff\1\54\1\uffff\32\54",
            "\12\54\7\uffff\32\54\4\uffff\1\54\1\uffff\32\54",
            "\12\u00d3",
            "\12\u00d3\20\uffff\1\160\37\uffff\1\160",
            "\12\54\7\uffff\32\54\4\uffff\1\54\1\uffff\32\54",
            "",
            "",
            "\1\u00e3",
            "\12\54\7\uffff\32\54\4\uffff\1\54\1\uffff\32\54",
            "\1\u00e5",
            "\12\54\7\uffff\32\54\4\uffff\1\54\1\uffff\32\54",
            "\12\54\7\uffff\32\54\4\uffff\1\54\1\uffff\32\54",
            "\12\54\7\uffff\32\54\4\uffff\1\54\1\uffff\32\54",
            "",
            "",
            "\12\54\7\uffff\32\54\4\uffff\1\54\1\uffff\32\54",
            "",
            "",
            "",
            "\1\u00ea",
            "",
            "\12\54\7\uffff\32\54\4\uffff\1\54\1\uffff\32\54",
            "",
            "",
            "",
            "",
            "\12\54\7\uffff\32\54\4\uffff\1\54\1\uffff\32\54",
            "",
            ""
    };

    static final short[] DFA36_eot = DFA.unpackEncodedString(DFA36_eotS);
    static final short[] DFA36_eof = DFA.unpackEncodedString(DFA36_eofS);
    static final char[] DFA36_min = DFA.unpackEncodedStringToUnsignedChars(DFA36_minS);
    static final char[] DFA36_max = DFA.unpackEncodedStringToUnsignedChars(DFA36_maxS);
    static final short[] DFA36_accept = DFA.unpackEncodedString(DFA36_acceptS);
    static final short[] DFA36_special = DFA.unpackEncodedString(DFA36_specialS);
    static final short[][] DFA36_transition;

    static {
        int numStates = DFA36_transitionS.length;
        DFA36_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA36_transition[i] = DFA.unpackEncodedString(DFA36_transitionS[i]);
        }
    }

    class DFA36 extends DFA {

        public DFA36(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 36;
            this.eot = DFA36_eot;
            this.eof = DFA36_eof;
            this.min = DFA36_min;
            this.max = DFA36_max;
            this.accept = DFA36_accept;
            this.special = DFA36_special;
            this.transition = DFA36_transition;
        }
        public String getDescription() {
            return "1:1: Tokens : ( T__84 | T__85 | T__86 | T__87 | T__88 | T__89 | T__90 | T__91 | T__92 | T__93 | T__94 | T__95 | T__96 | T__97 | T__98 | T__99 | T__100 | T__101 | T__102 | T__103 | T__104 | T__105 | T__106 | T__107 | T__108 | T__109 | T__110 | T__111 | T__112 | LPAREN | RPAREN | LBRACK | RBRACK | COLON | COMMA | SEMI | PLUS | MINUS | STAR | SLASH | VBAR | AMPER | LESS | GREATER | ASSIGN | PERCENT | BACKQUOTE | LCURLY | RCURLY | CIRCUMFLEX | TILDE | EQUAL | NOTEQUAL | ALT_NOTEQUAL | LESSEQUAL | LEFTSHIFT | GREATEREQUAL | RIGHTSHIFT | PLUSEQUAL | MINUSEQUAL | DOUBLESTAR | STAREQUAL | DOUBLESLASH | SLASHEQUAL | VBAREQUAL | PERCENTEQUAL | AMPEREQUAL | CIRCUMFLEXEQUAL | LEFTSHIFTEQUAL | RIGHTSHIFTEQUAL | DOUBLESTAREQUAL | DOUBLESLASHEQUAL | DOT | FLOAT | LONGINT | INT | COMPLEX | NAME | STRING | CONTINUED_LINE | NEWLINE | WS | LEADING_WS | COMMENT );";
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            IntStream input = _input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA36_115 = input.LA(1);

                         
                        int index36_115 = input.index();
                        input.rewind();

                        s = -1;
                        if ( ((startPos>0)) ) {s = 161;}

                        else if ( ((startPos==0)) ) {s = 116;}

                         
                        input.seek(index36_115);

                        if ( s>=0 ) return s;
                        break;

                    case 1 : 
                        int LA36_49 = input.LA(1);

                         
                        int index36_49 = input.index();
                        input.rewind();

                        s = -1;
                        if ( (LA36_49==' ') && (((startPos==0)||(startPos>0)))) {s = 48;}

                        else if ( (LA36_49=='\n'||LA36_49=='\r') && ((startPos==0))) {s = 116;}

                        else if ( (LA36_49=='\t') && (((startPos==0)||(startPos>0)))) {s = 49;}

                        else if ( (LA36_49=='#') && ((startPos==0))) {s = 117;}

                        else s = 115;

                         
                        input.seek(index36_49);

                        if ( s>=0 ) return s;
                        break;

                    case 2 : 
                        int LA36_48 = input.LA(1);

                         
                        int index36_48 = input.index();
                        input.rewind();

                        s = -1;
                        if ( (LA36_48==' ') && (((startPos==0)||(startPos>0)))) {s = 48;}

                        else if ( (LA36_48=='\n'||LA36_48=='\r') && ((startPos==0))) {s = 116;}

                        else if ( (LA36_48=='\t') && (((startPos==0)||(startPos>0)))) {s = 49;}

                        else if ( (LA36_48=='#') && ((startPos==0))) {s = 117;}

                        else s = 115;

                         
                        input.seek(index36_48);

                        if ( s>=0 ) return s;
                        break;

                    case 3 : 
                        int LA36_0 = input.LA(1);

                         
                        int index36_0 = input.index();
                        input.rewind();

                        s = -1;
                        if ( (LA36_0=='a') ) {s = 1;}

                        else if ( (LA36_0=='b') ) {s = 2;}

                        else if ( (LA36_0=='c') ) {s = 3;}

                        else if ( (LA36_0=='d') ) {s = 4;}

                        else if ( (LA36_0=='e') ) {s = 5;}

                        else if ( (LA36_0=='f') ) {s = 6;}

                        else if ( (LA36_0=='g') ) {s = 7;}

                        else if ( (LA36_0=='i') ) {s = 8;}

                        else if ( (LA36_0=='l') ) {s = 9;}

                        else if ( (LA36_0=='n') ) {s = 10;}

                        else if ( (LA36_0=='o') ) {s = 11;}

                        else if ( (LA36_0=='p') ) {s = 12;}

                        else if ( (LA36_0=='r') ) {s = 13;}

                        else if ( (LA36_0=='t') ) {s = 14;}

                        else if ( (LA36_0=='w') ) {s = 15;}

                        else if ( (LA36_0=='y') ) {s = 16;}

                        else if ( (LA36_0=='(') ) {s = 17;}

                        else if ( (LA36_0==')') ) {s = 18;}

                        else if ( (LA36_0=='[') ) {s = 19;}

                        else if ( (LA36_0==']') ) {s = 20;}

                        else if ( (LA36_0==':') ) {s = 21;}

                        else if ( (LA36_0==',') ) {s = 22;}

                        else if ( (LA36_0==';') ) {s = 23;}

                        else if ( (LA36_0=='+') ) {s = 24;}

                        else if ( (LA36_0=='-') ) {s = 25;}

                        else if ( (LA36_0=='*') ) {s = 26;}

                        else if ( (LA36_0=='/') ) {s = 27;}

                        else if ( (LA36_0=='|') ) {s = 28;}

                        else if ( (LA36_0=='&') ) {s = 29;}

                        else if ( (LA36_0=='<') ) {s = 30;}

                        else if ( (LA36_0=='>') ) {s = 31;}

                        else if ( (LA36_0=='=') ) {s = 32;}

                        else if ( (LA36_0=='%') ) {s = 33;}

                        else if ( (LA36_0=='`') ) {s = 34;}

                        else if ( (LA36_0=='{') ) {s = 35;}

                        else if ( (LA36_0=='}') ) {s = 36;}

                        else if ( (LA36_0=='^') ) {s = 37;}

                        else if ( (LA36_0=='~') ) {s = 38;}

                        else if ( (LA36_0=='!') ) {s = 39;}

                        else if ( (LA36_0=='.') ) {s = 40;}

                        else if ( (LA36_0=='0') ) {s = 41;}

                        else if ( ((LA36_0 >= '1' && LA36_0 <= '9')) ) {s = 42;}

                        else if ( (LA36_0=='u') ) {s = 43;}

                        else if ( ((LA36_0 >= 'A' && LA36_0 <= 'Z')||LA36_0=='_'||LA36_0=='h'||(LA36_0 >= 'j' && LA36_0 <= 'k')||LA36_0=='m'||LA36_0=='q'||LA36_0=='s'||LA36_0=='v'||LA36_0=='x'||LA36_0=='z') ) {s = 44;}

                        else if ( (LA36_0=='\"'||LA36_0=='\'') ) {s = 45;}

                        else if ( (LA36_0=='\\') ) {s = 46;}

                        else if ( (LA36_0=='\n'||LA36_0=='\r') ) {s = 47;}

                        else if ( (LA36_0==' ') && (((startPos==0)||(startPos>0)))) {s = 48;}

                        else if ( (LA36_0=='\t') && (((startPos==0)||(startPos>0)))) {s = 49;}

                        else if ( (LA36_0=='#') && (((startPos==0)||(startPos>0)))) {s = 50;}

                         
                        input.seek(index36_0);

                        if ( s>=0 ) return s;
                        break;
            }
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 36, _s, input);
            error(nvae);
            throw nvae;
        }

    }
 

}